[DO NOT MERGE] POC: Add language-level tagged unions (enum union) and pattern matching (switch expressions) by MetaLang · Pull Request #23744 · dlang/dmd

MetaLang · 2026-08-29T05:36:26Z

This PR adds language-level support for Rust/Swift-style tagged unions (called enum union), and dedicated syntax for matching on their variants in the form of switch expressions.

I wasn't satisfied with @rikkimax's approach in #23540, which is more in line with the structural approach taken by ML/Haskell, so I decided to implement it myself. And by myself, I mean an LLM - I wrote the spec, but it wrote all of the code and tests, and it was pretty quick and dirty. Consequently and unsurprisingly, most of the test runners are failing.

module net.event_processor;

import core.stdc.stdio;
import std.format : format;

// 1. Hybrid Tagged Union: Primitives, Slices, Tuples, and Named Records
enum union NetworkEvent
{
    // Bare primitive & slice types (types act directly as discriminant tags)
    case int,                    // Raw error code
    case ubyte[],                // Unparsed raw payload buffer

    // Unit variants
    case Disconnected(),
    case Heartbeat(),

    // Positional (tuple-like) variants
    case Ping(ulong, ushort),

    // Named record variants
    case HttpRequest { string method; string path; ushort statusCode; };

    // Embedded methods
    string summary() const @safe
    {
        // Switch expression with fat-arrow arms and comma separators
        return switch (this)
        {
            case int errCode               => "Socket Error: %d".format(errCode),
            case ubyte[] data              => "Raw Frame (%d bytes)".format(data.length),
            case Disconnected              => "Connection Closed",
            case Heartbeat                 => "Keep-Alive ACK",
            case Ping(ts, seq)             => "Ping [seq=%d, ts=%d]".format(seq, ts),
            case HttpRequest { method, path, statusCode } => "%s %s -> %d".format(method, path, statusCode),
        };
    }
}

// 2. Request Dispatcher demonstrating elimination and return type unification
struct ConnectionHandler
{
    ulong activeSessionId;

    // Dispatches an incoming event and computes an action response code
    int handleEvent(NetworkEvent event) @safe
    {
        // All arms strictly unify via Least Upper Bound (LUB)
        return switch (event)
        {
            case int err => err < 0 ? err : -1,
            case ubyte[] frame => processFrame(frame),
            case Heartbeat => 0,
            case Ping(ts, seq) => sendPong(ts, seq),
            case HttpRequest { statusCode, ... } => statusCode, // Partial record destructuring
            case Disconnected => throw new Exception("Terminating disconnected session"),
        };
    }

    private int processFrame(const ubyte[] frame) @safe pure nothrow => 200;
    private int sendPong(ulong ts, ushort seq) @safe nothrow => 1;
}

void main() @safe
{
    // Supports assignment-style construction
    NetworkEvent e1 = 404;
    NetworkEvent e2 = [0xDE, 0xAD, 0xBE, 0xEF];

    // Labeled variant construction via synthesized static factories for named case variants
    auto e3 = NetworkEvent.Heartbeat;
    auto e4 = NetworkEvent.Ping(1_700_000_000, 42);
    auto e5 = NetworkEvent.HttpRequest("GET", "/api/v1/status", 200);

    auto handler = ConnectionHandler(1001);

    assert(handler.handleEvent(e1) == -1);
    assert(handler.handleEvent(e3) == 0);
    assert(handler.handleEvent(e4) == 1);
    assert(handler.handleEvent(e5) == 200);
    assert(e5.summary() == "GET /api/v1/status -> 200");
}

See enum_union_guide.md for an explanation of how the features work.

Included

parser/semantic support for enum unions
bare-type variants
switch matching, guards, and exhaustiveness checks
validation for duplicate cases/types and lifecycle restrictions
runtime + regression tests

@xoxorwr @limepoutine @Herringway

github-actions · 2026-08-29T05:46:55Z

DMD perf check

Metric	Base	PR	Δ
compile hello.d (instr)	214.9 M	224.7 M	+4.577%
compile hello.d -O -release (instr)	233.2 M	243.0 M	+4.218%
compile Phobos (instr)	5,123.9 M	5,191.0 M	+1.310%
compile vibe.d (instr)	15,130.1 M	15,304.2 M	+1.151%

Breakdown — compile hello.d

Phase (wall, self time)	Base	PR	Δ
sema3	6.0 ms	5.4 ms	-9.27%
sema_other	13.3 ms	13.7 ms	+3.03%
sema1	11.3 ms	11.1 ms	-1.83%
parse	34.9 ms	34.7 ms	-0.58%
codegen	1.9 ms	1.9 ms	+1.41%

Breakdown — compile Phobos

+67.1 M instructions: frontend +66.9 M (+1.83%), codegen +0.2 M (+0.01%)

Phase (wall, self time)	Base	PR	Δ
sema3	591 ms	584 ms	-1.24%
parse	113 ms	118 ms	+4.76%
codegen	402 ms	405 ms	+0.91%
sema1	223 ms	220 ms	-1.01%
sema_other	197 ms	199 ms	+0.70%
ctfe	14.6 ms	14.0 ms	-4.16%
sema2	2.1 ms	2.1 ms	+2.20%
inline	4.3 ms	4.3 ms	-0.49%

All measurements

Metric	Base	PR	Δ
compile hello.d (instr)	214.9 M	224.7 M	+4.577%
compile hello.d -O -release (instr)	233.2 M	243.0 M	+4.218%
compile Phobos (instr)	5,123.9 M	5,191.0 M	+1.310%
compile Phobos codegen (instr)	1,472.8 M	1,473.0 M	+0.014%
compile vibe.d (instr)	15,130.1 M	15,304.2 M	+1.151%
dmd binary size (stripped)	6.86 MB	6.87 MB	+0.03%
hello binary size (stripped)	0.72 MB	0.72 MB	0.00%
peak RSS (compile hello.d)	43.43 MB	43.37 MB	-0.14%
peak RSS (compile Phobos)	618.8 MB	620.0 MB	+0.20%
peak RSS (compile vibe.d)	1917 MB	1917 MB	-0.01%
compile dmd itself (wall)	12.0 s	12.1 s	+0.79%
compile hello.d (wall)	67.4 ms	66.9 ms	-0.78%
compile Phobos (wall)	1,546 ms	1,546 ms	+0.01%

_{cc20c6d vs merge-base 7e0b115 · about these metrics}

rikkimax · 2026-08-29T06:06:50Z

+                    from.isFunction_Delegate_PtrToFunction()
+                    ? MATCH.convert : MATCH.exact;
+                const isNullUnitVariant = from.toBasetype().ty == Tnull &&
+                    variant.payload.length == 0 && variant.ident == Identifier.idPool("None");


Try to avoid comparing identifiers by string, chuck None into the table and do a pointer comparison instead.

rikkimax · 2026-08-29T06:07:37Z

    alias Parameters            = Array!(Parameter);
    alias Statements            = Array!(Statement);
    alias Catches               = Array!(Catch);
+    inout(SwitchExp) isSwitchExp() { return op == EXP.switchExpression ? cast(typeof(return))this : null; }


That doesn't look like the right place for it.

rikkimax · 2026-08-29T06:17:11Z

Some of the implementation is certainly cleaner.

It doesn't handle integer confusion, which is why I banned that.

No handling of alias sequences and expansion into variants. Kinda important use case both in literature and in D code.

You did not solve for the overlapped error.

You support multiple values per variant, I assume that tuples will exist to define that into existance.

It does not support by-ref, vs by-value this is a killer feature over library.

It does not support chaining like it would via UFCS, this is a downgrade over library.

It requires a lot of redundent tokens, you don't need case inside of the declaration, nor in switch expression.

The extra combination of enum and union I very much dislike it. As we've learned from DIP1000 that is not a good thing.

MetaLang · 2026-08-29T06:37:02Z

Some of the implementation is certainly cleaner.

It's just vibe-coded LLM slop I banged out to show my vision for how such a feature would work.

It doesn't handle integer confusion, which is why I banned that.

I'm not completely sure what you're referring to. It will reject cases like:

enum union Num
{
    int,
    long,
}

Num n = 0;

Unless you disambiguate with a cast or literal syntax.

No handling of alias sequences and expansion into variants. Kinda important use case both in literature and in D code.

Ya, too complicated to implement for a POC, but it should be supported through .tupleof or something similar.

You did not solve for the overlapped error.

What's that?

You support multiple values per variant, I assume that tuples will exist to define that into existance.

The variants are "tuple-like", but currently don't have any relation to tuples. I don't think that's a necessity, but may be nice to have. The struct variants are really useful though.

It does not support by-ref, vs by-value this is a killer feature over library.

Ya I'm not sure what to do about that because of the safety issues. Maybe with your fast DFA it'd be safe to support.

It does not support chaining like it would via UFCS, this is a downgrade over library.

That feature is maybe a nice to have, but it's very easy to emulate with a switch expression inside a UFCS function and IMO doesn't add a whole lot.

It requires a lot of redundent tokens, you don't need case inside of the declaration, nor in switch expression.

Those are for readability/comprehensibility more than anything. It makes it more clear to the people reading and writing the code what's going on semantically, and I think that the case token before each variant might be necessary for disambiguation if you also wanna have member functions inside the body, but I may be misremembering.

The case tokens in switch expressions are to match how you declare cases in the enum union body, and to make it more familiar for programmers who are used to the regular switch. But yeah they're unnecessary in terms of parsing.

The extra combination of enum and union I very much dislike it. As we've learned from DIP1000 that is not a good thing.

I think it's good for signalling to the programmer what this construct does and how it works. It's like a union, but with an enumerated list of cases (and enums are traditionally used for the tag in a tagged union).

Also note that Rust, Swift, C#, Zig and Odin all use the keywords enum and/or union (in Zig it's literally union(enum) for their versions of this concept), and half of those languages use switch expressions instead of match.

You could just as easily use sumtype instead, but IMO that term is loaded and means different things to different people.

rikkimax · 2026-08-29T06:40:12Z

No handling of alias sequences and expansion into variants. Kinda important use case both in literature and in D code.

Ya, too complicated to implement for a POC, but it should be supported through .tupleof or something similar.

You did not solve for the overlapped error.

What's that?

Its an error for @safe code, to prevent accessing of union fields.

You support multiple values per variant, I assume that tuples will exist to define that into existance.

The variants are "tuple-like", but currently don't have any relation to tuples. I don't think that's a necessity, but may be nice to have. The struct variants are really useful though.

It does not support by-ref, vs by-value this is a killer feature over library.

Ya I'm not sure what to do about that because of the safety issues. Maybe with your fast DFA it'd be safe to support.

I've got to go do that on my PR.

It does not support chaining like it would via UFCS, this is a downgrade over library.

That feature is maybe a nice to have, but it's very easy to emulate with a switch expression inside a UFCS function and IMO doesn't add a whole lot.

Booo functions, not analyzable! Not clean chaining of input ranges.

It requires a lot of redundent tokens, you don't need case inside of the declaration, nor in switch expression.

Those are for readability/comprehensibility more than anything. It makes it more clear to the people reading and writing the code what's going on semantically, and I think that the case token before each variant might be necessary for disambiguation if you also wanna have member functions inside the body, but I may be misremembering.

The extra combination of enum and union I very much dislike it. As we've learned from DIP1000 that is not a good thing.

I think it's good for signalling to the programmer what this construct does and how it works. It's like a union, but with an enumerated list of cases (and enums are traditionally used for the tag in a tagged union). You could just as easily use sumtype instead, but IMO that term is loaded and means different things to different people.

Add language-level tagged enum unions and switch-expression matching.\n\nFeatures:\n- Parse enum union declarations with named, tuple, record, alias, and bare-type variants.\n- Synthesize tagged storage, payload structs, variant factories, and destruction support.\n- Support implicit construction for unambiguous bare-type variants and reject duplicate or ambiguous cases.\n- Expand static foreach and static if enum-union cases in their correct semantic scope.\n- Add tuple and record pattern bindings, named/literal field checks, rest patterns, and guarded arms.\n- Diagnose non-union patterns, unmatched variants, invalid positional patterns, duplicate defaults, and the 256-variant limit.\n- Add frontend matrix-based usefulness checks for redundant arms, redundant defaults, guarded coverage, and exhaustiveness witnesses.\n- Add specification, runnable, compilable, and fail-compilation regression coverage.

Replace the obsolete record discard spelling with the supported syntax in the NetworkEvent example.

- add parser and AST support for enum union declarations, named/unit/record/bare variants, templates, static foreach, variant UDAs, and struct-equivalent declaration attributes - synthesize tagged storage, named factories, bare-variant constructors, and lifecycle support for payloads - add implicit bare-variant conversion with ambiguity diagnostics and preserve enum-union non-callability - implement enum-union switch expressions with positional, record, type, rest, guard, default, redundancy, and exhaustiveness handling - diagnose malformed switch patterns, duplicate cases, unknown bare types, oversized unions, and invalid variant declarations - prevent user constructors from reading this before whole-value initialization, with branch-aware constructor flow tracking - eliminate duplicate complex and imaginary transition deprecations from generated constructor parameters - document enum union grammar, construction, pattern matching, member declarations, and limitations - add runnable, compilable, and fail-compilation coverage for syntax, conversion, constructors, UDAs, attributes, diagnostics, patterns, and lifecycle behavior

Add enum-union pattern matching and construction refinements: - resolve bare and qualified type patterns, including identifier bindings - support payload bindings for named variants and share unit payload storage - diagnose self aliases, unknown bare types, no-argument constructors, and ambiguous bare conversions - resolve property-valued switch conditions and improve switch-expression formatting - allow arrow-arm switch expressions in statement position and diagnose discarded no-effect switches - preserve parser recovery for malformed switch expressions - add focused compile, fail, and runnable regression coverage

Add enum union support and tests

e174f31

MetaLang changed the title ~~Add enum union support and tests~~ Add language-level tagged unions (enum union) and pattern matching (switch expressions) Aug 29, 2026

rikkimax reviewed Aug 29, 2026

View reviewed changes

MetaLang mentioned this pull request Aug 29, 2026

Implement sumtypes and matching #23540

Draft

MetaLang changed the title ~~Add language-level tagged unions (enum union) and pattern matching (switch expressions)~~ [DO NOT MERGE] Add language-level tagged unions (enum union) and pattern matching (switch expressions) Aug 29, 2026

MetaLang changed the title ~~[DO NOT MERGE] Add language-level tagged unions (enum union) and pattern matching (switch expressions)~~ [DO NOT MERGE] POC: Add language-level tagged unions (enum union) and pattern matching (switch expressions) Aug 29, 2026

MetaLang added 4 commits September 8, 2026 02:45

Fix enum union discard pattern example

3203b3e

Replace the obsolete record discard spelling with the supported syntax in the NetworkEvent example.

Navigation Menu

Uh oh!

Uh oh!

[DO NOT MERGE] POC: Add language-level tagged unions (enum union) and pattern matching (switch expressions) - #23744

[DO NOT MERGE] POC: Add language-level tagged unions (enum union) and pattern matching (switch expressions)#23744
MetaLang wants to merge 5 commits into
dlang:masterfrom
MetaLang:sumtype-poc

MetaLang commented Aug 29, 2026 •

edited

Loading

Uh oh!

github-actions Bot commented Aug 29, 2026 •

edited

Loading

Uh oh!

rikkimax Aug 29, 2026 •

edited

Loading

Uh oh!

rikkimax Aug 29, 2026

Uh oh!

rikkimax commented Aug 29, 2026

Uh oh!

MetaLang commented Aug 29, 2026 •

edited

Loading

Uh oh!

rikkimax commented Aug 29, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

Uh oh!

Uh oh!

Conversation

MetaLang commented Aug 29, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Included

Uh oh!

github-actions Bot commented Aug 29, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

DMD perf check

Uh oh!

rikkimax Aug 29, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

rikkimax Aug 29, 2026

Choose a reason for hiding this comment

Uh oh!

rikkimax commented Aug 29, 2026

Uh oh!

MetaLang commented Aug 29, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rikkimax commented Aug 29, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

MetaLang commented Aug 29, 2026 •

edited

Loading

github-actions Bot commented Aug 29, 2026 •

edited

Loading

rikkimax Aug 29, 2026 •

edited

Loading

MetaLang commented Aug 29, 2026 •

edited

Loading